package com.pine.common.util.json;

import cn.hutool.core.util.StrUtil;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.time.ZoneId;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.TimeZone;
import java.util.regex.Pattern;

/**
 * json工具
 *
 * @author pine manage
 * @since 2024-10-30
 */
public class JsonUtil {
    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();

    private static final String DEFAULT_DATE_TIME_PATTERN = "yyyy-MM-dd HH:mm:ss";

    /**
     * 正则表达式，用于判断是否是json串(只判断是否是{}, []的结构)
     */
    private static final Pattern PREPARE_JSON_PATTERN = Pattern.compile("^\\{.*}$|^\\[.*]$");

    public JsonUtil() {
    }

    /**
     * json转对象
     *
     * @param json        字符串
     * @param clazz       对象类型
     * @param ignoreError 是否忽略错误，true时返回null，false时抛出异常
     * @param <T>         对象泛型类型
     * @return 对象
     */
    public static <T> T json2Object(String json, Class<T> clazz, boolean ignoreError) {
        try {
            return OBJECT_MAPPER.readValue(json, clazz);
        } catch (IOException e) {
            if (ignoreError) {
                return null;
            }
            throw new RuntimeException("解析json错误");
        }
    }

    /**
     * json转对象
     *
     * @param json  字符串
     * @param clazz 对象类型
     * @param <T>   对象泛型类型
     * @return 对象
     */
    public static <T> T json2Object(String json, Class<T> clazz) {
        return json2Object(json, clazz, false);
    }


    /**
     * json转对象(忽略错误，出错时返回null)
     *
     * @param json  json字符串
     * @param clazz 类型
     * @param <T>   对象泛型类型
     * @return 对象
     */
    public static <T> T json2ObjectIgnoreError(String json, Class<T> clazz) {
        return json2Object(json, clazz, true);
    }

    /**
     * json转对象
     *
     * @param json 字符串
     * @param tr   类型封装
     * @param <T>  对象泛型类型
     * @return 对象
     */
    public static <T> T json2Object(String json, TypeRef<T> tr) {
        try {
            return OBJECT_MAPPER.readValue(json, tr.getType());
        } catch (IOException e) {
            throw new RuntimeException("解析json错误");
        }
    }

    /**
     * json转json树
     *
     * @param json json字符串
     * @return json树
     */
    public static JsonNode json2Tree(String json) {
        try {
            return OBJECT_MAPPER.readTree(json);
        } catch (Exception e) {
            throw new RuntimeException("解析json错误");
        }
    }

    /**
     * json转map
     *
     * @param json  json字符串
     * @param clazz 类型
     * @param <T>   对象泛型类型
     * @return map
     */
    public static <T> Map<String, T> toObjectMap(String json, Class<T> clazz) {
        try {
            JavaType javaType = OBJECT_MAPPER.getTypeFactory().constructParametricType(Map.class, String.class, clazz);
            return OBJECT_MAPPER.readValue(json, javaType);
        } catch (IOException e) {
            throw new RuntimeException("解析json错误");
        }
    }

    /**
     * json转list
     *
     * @param json  json字符串
     * @param clazz 类型
     * @param <T>   对象泛型类型
     * @return list
     */
    public static <T> List<T> toObjectList(String json, Class<T> clazz) {
        JavaType javaType = OBJECT_MAPPER.getTypeFactory().constructParametricType(ArrayList.class, clazz);
        try {
            return OBJECT_MAPPER.readValue(json, javaType);
        } catch (IOException e) {
            throw new RuntimeException("解析json错误");
        }
    }


    /**
     * 对象转json
     *
     * @param entity 实体对象
     * @param <T>    对象泛型类型
     * @return json字符串
     */
    public static <T> String object2Json(T entity) {
        try {
            return OBJECT_MAPPER.writeValueAsString(entity);
        } catch (IOException e) {
            throw new RuntimeException("转换json错误");
        }
    }

    /**
     * 对象转json树
     *
     * @param obj 对象
     * @return json树
     */
    public static JsonNode object2TreeJson(Object obj) {
        try {
            return OBJECT_MAPPER.valueToTree(obj);
        } catch (Exception e) {
            throw new RuntimeException("转换json错误");
        }
    }

    /**
     * 判断一个字符串是否是json串
     *
     * @param content 内容
     * @return true 是，false 否
     */
    public static boolean isJson(String content) {
        if (StrUtil.isBlank(content)) {
            return false;
        }

        // 预判是否是json串
        if (PREPARE_JSON_PATTERN.matcher(content).matches()) {
            try {
                OBJECT_MAPPER.readTree(content);
                return true;
            } catch (Exception e) {
                return false;
            }
        }
        return false;
    }


    /**
     * 获取objectMapper对象
     *
     * @return objectMapper对象
     */
    public static ObjectMapper getObjectMapper() {
        return OBJECT_MAPPER;
    }


    static {
        // 禁止日期/时间默认序列化为时间戳
        OBJECT_MAPPER.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
        // 设置时区为gmt+8
        OBJECT_MAPPER.setTimeZone(TimeZone.getTimeZone(ZoneId.systemDefault()));
        // 设置日期格式
        OBJECT_MAPPER.setDateFormat(new SimpleDateFormat(DEFAULT_DATE_TIME_PATTERN));
        // 允许单引号
        OBJECT_MAPPER.configure(JsonParser.Feature.ALLOW_SINGLE_QUOTES, true);
        // 将 BigDecimal 序列化为 bigDecimal.toPlainString(), 防止生成科学计数法
        OBJECT_MAPPER.configure(JsonGenerator.Feature.WRITE_BIGDECIMAL_AS_PLAIN, Boolean.TRUE);
        // 允许序列化空的POJO类（否则会抛出异常）
        OBJECT_MAPPER.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
        // 在遇到未知属性的时候不抛出异常
        OBJECT_MAPPER.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
        // 忽略值为默认值的属性
        OBJECT_MAPPER.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        // java8时间类型支持
        OBJECT_MAPPER.registerModule(new JavaTimeModule());
    }
}

